{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building Models in PyMC3\n",
    "\n",
    "Bayesian inference begins with specification of a probability model relating unknown variables to data. PyMC3 provides the basic building blocks for Bayesian probability models: \n",
    "\n",
    "1. stochastic random variables\n",
    "2. deterministic variables\n",
    "3. factor potentials. \n",
    "\n",
    "A **stochastic random variable** is a factor whose value is not completely determined by its parents, while the value of a **deterministic random variable** is entirely determined by its parents. Most models can be constructed using only these two variable types. The third quantity, the **factor potential**, is *not* a variable but simply a\n",
    "log-likelihood term or constraint that is added to the joint log-probability to modify it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Inferring patterns in UK coal mining disasters\n",
    "\n",
    "To motivate this section, let's model a different dataset: a time series of recorded coal mining \n",
    "disasters in the UK from 1851 to 1962.\n",
    "\n",
    "Occurrences of disasters in the time series is thought to be derived from a \n",
    "Poisson process with a large rate parameter in the early part of the time \n",
    "series, and from one with a smaller rate in the later part. We are interested \n",
    "in locating the change point in the series, which perhaps is related to changes \n",
    "in mining safety regulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "year = np.arange(1851, 1962)\n",
    "disasters_data = np.array([4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6,\n",
    "                         3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5,\n",
    "                         2, 2, 3, 4, 2, 1, 3, 2, 2, 1, 1, 1, 1, 3, 0, 0,\n",
    "                         1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1,\n",
    "                         0, 1, 0, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2,\n",
    "                         3, 3, 1, 1, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4,\n",
    "                         0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_context('notebook')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12.5, 3.5))\n",
    "n_count_data = len(disasters_data)\n",
    "ax.bar(year, disasters_data, color=\"#348ABD\")\n",
    "ax.set_xlabel(\"Year\")\n",
    "ax.set_ylabel(\"Disasters\")\n",
    "ax.set_title(\"UK coal mining disasters, 1851-1962\")\n",
    "ax.set_xlim(1851, 1962);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to use Poisson random variables for this type of count data. Denoting year $i$'s accident count by $y_i$, \n",
    "\n",
    "$$ y_i \\sim \\text{Poisson}(\\lambda)  $$\n",
    "\n",
    "The modeling problem revolves around estimating the values of the $\\lambda$ parameters. Looking at the time series above, it appears that the rate declines later in the time series.\n",
    "\n",
    "A ***changepoint model*** identifies a point (year) during the observation period (call it $\\tau$) after which the parameter $\\lambda$ drops to a lower value. So we are estimating two $\\lambda$ parameters: one for the early period and another for the late period.\n",
    "\n",
    "$$\n",
    "\\lambda = \n",
    "\\begin{cases}\n",
    "\\lambda_1  & \\text{if } t \\lt \\tau \\cr\n",
    "\\lambda_2 & \\text{if } t \\ge \\tau\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "We need to assign prior probabilities to both $\\lambda$ parameters. The gamma distribution not only provides a continuous density function for positive numbers, but it is also **conjugate** with the Poisson sampling distribution. We will specify suitably vague hyperparameters $\\alpha$ and $\\beta$ for both priors.\n",
    "\n",
    "$$\\begin{aligned}\n",
    "\\lambda_1 &\\sim \\text{Gamma}( \\alpha, \\beta ) \\cr\n",
    "\\lambda_2 &\\sim \\text{Gamma}( \\alpha, \\beta )\n",
    "\\end{aligned}$$\n",
    "\n",
    "Since we do not have any intuition about the location of the changepoint (prior to viewing the data), we will assign a discrete uniform prior over all years 1851-1962.\n",
    "\n",
    "$$\\begin{aligned}\n",
    "& \\tau \\sim \\text{Uniform(1851,1962) }\\cr\n",
    "& \\Rightarrow P( \\tau = k ) = \\frac{1}{111}\n",
    "\\end{aligned}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The FreeRV class\n",
    "\n",
    "A stochastic variable is represented in PyMC3 by a `FreeRV` class. This structure adds functionality to Theano's `TensorVariable` class, by mixing in the PyMC `Factor` class. A `Factor` is used whenever a variable contributes a log-probability term to a model. Hence, you know a variable is a subclass of `Factor` whenever it has a `logp` method, as we saw in the previous section.\n",
    "\n",
    "A `FreeRV` object has several important attributes:\n",
    "\n",
    "`dshape`\n",
    ":   The variable's shape.\n",
    "\n",
    "`dsize`\n",
    ":   The overall size of the variable.\n",
    "\n",
    "`distribution`\n",
    ":   The probability density or mass function that describes the distribution of the variable's values.\n",
    "\n",
    "`logp`\n",
    ":   The log-probability of the variable's current value given the values\n",
    "    of its parents.\n",
    "\n",
    "`init_value`\n",
    ":   The initial value of the variable, used by many algorithms as a starting point for model fitting.\n",
    "\n",
    "`model`\n",
    ":   The PyMC model to which the variable belongs.\n",
    "\n",
    "\n",
    "### Creation of stochastic random variables\n",
    "\n",
    "There are two ways to create stochastic random variables (`FreeRV` objects), which we will call the **automatic**, and **manual** interfaces.\n",
    "\n",
    "#### Automatic\n",
    "\n",
    "Stochastic random variables with standard distributions provided by PyMC3 can be created in a single line using special subclasses of the `Distribution` class. For example, as we have seen, the uniformly-distributed discrete variable $\\tau$ in the coal mining disasters model is created using the automatic interface as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymc3 import Model, Uniform\n",
    "\n",
    "with Model() as disaster_model:\n",
    "\n",
    "    switchpoint = Uniform('switchpoint', lower=0, upper=110)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, the rate parameters can automatically be given exponential priors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymc3 import Exponential\n",
    "\n",
    "with disaster_model:\n",
    "    early_mean = Exponential('early_mean', lam=1)\n",
    "    late_mean = Exponential('late_mean', lam=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyMC includes most of the probability density functions (for continuous variables) and probability mass functions (for discrete variables) used in statistical modeling. Continuous variables are represented by a specialized subclass of `Distribution` called `Continuous` and discrete variables by the `Discrete` subclass.\n",
    "\n",
    "The main differences between these two sublcasses are in the `dtype` attribute (`int64` for `Discrete` and `float64` for `Continuous`) and the `defaults` attribute, which determines which summary statistic to use for initial values when one is not specified ('mode' for `Discrete` and 'median', 'mean', and 'mode' for `Continuous`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('median', 'mean', 'mode')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "switchpoint.distribution.defaults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we wish to use a particular statistical distribution, without using it as a variable in a model; for example, to generate random numbers from the distribution. This class method allows that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{None} \\sim \\text{Exponential}(\\mathit{lam}=1.0)$"
      ],
      "text/plain": [
       "<pymc3.distributions.continuous.Exponential at 0x7c285ef5a828>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Exponential.dist(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Manual\n",
    "\n",
    "The uniformly-distributed discrete stochastic variable `switchpoint` in the disasters model could alternatively be created from a function that computes its log-probability as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymc3 import DensityDist\n",
    "from pymc3.math import switch\n",
    "\n",
    "with Model():\n",
    "    \n",
    "    def uniform_logp(value, lower=0, upper=111):\n",
    "        \"\"\"The switchpoint for the rate of disaster occurrence.\"\"\"\n",
    "        return switch((value > upper) | (value < lower), -np.inf, -np.log(upper - lower + 1))\n",
    "\n",
    "    switchpoint = DensityDist('switchpoint', logp=uniform_logp, dtype='int64')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(-4.71849887)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "switchpoint.logp({'switchpoint':4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(-4.71849887)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "switchpoint.logp({'switchpoint': 44})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(-inf)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "switchpoint.logp({'switchpoint':-1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A couple of things to notice: while the function specified for the `logp` argument can be an arbitrary Python function, it must use **Theano operators and functions** (in this case, `switch`) in its body. This is because one or more of the arguments passed to the function may be `TensorVariables`, and they must be supported. Also, we passed the value to be evaluated by the `logp` function as a **dictionary**, rather than as a plain integer. By convention, values in PyMC3 are passed around as a data structure called a `Point`. Points in parameter space are represented by dictionaries with parameter names as they keys and the value of the parameters as the values.\n",
    "\n",
    "To emphasize, the Python function passed to `DensityDist` should compute the *log*-density or *log*-probability of the variable. That is why the return value in the example above is `-log(upper-lower+1)` rather than `1/(upper-lower+1)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The ObservedRV Class\n",
    "\n",
    "Stochastic random variables whose values are observed (*i.e.* data likelihoods) are represented by a different class than unobserved random variables. A `ObservedRV` object is instantiated any time a stochastic variable is specified with data passed as the `observed` argument. \n",
    "\n",
    "Otherwise, observed stochastic random variables are created via the same interfaces as unobserved: **automatic** or **manual**. As an example of an automatic instantiation, consider a Poisson data likelihood :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymc3 import Poisson\n",
    "\n",
    "with disaster_model:\n",
    "    \n",
    "    disasters = Poisson('disasters', mu=3, observed=[3,4,1,2,0,2,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A manual instantiation would be similar to that for a stochastic random variable, except `DensityDist` would recieve an `observed` argument. Here is an example of an *exponential survivial likelihood*:\n",
    "\n",
    "```python\n",
    "def logp(failure, value):\n",
    "    return (failure * log(lam) - lam * value).sum()\n",
    "\n",
    "x = DensityDist('x', logp, observed={'failure':failure, 'value':t})\n",
    "```\n",
    "\n",
    "Notice in this example that there are two vetors observed data for the likelihood `x`, passed as a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important responsibility of `ObservedRV` is to automatically handle missing values in the data, when they are present (absent?). See PyMC3 documentation for details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deterministic Variables\n",
    "\n",
    "A deterministic variable is one whose values are **completely determined** by the values of their parents. For example, in our disasters model, `rate` is a deterministic variable.\n",
    "\n",
    "```python\n",
    "with disaster_model:\n",
    "    \n",
    "    rate = pm.Deterministic('rate', switch(switchpoint >= np.arange(112), early_mean, late_mean))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so `rate`'s value can be computed exactly from the values of its parents `early_mean`, `late_mean` and `switchpoint`.\n",
    "\n",
    "There are two types of deterministic variables in PyMC3\n",
    "\n",
    "#### Anonymous deterministic variables\n",
    "\n",
    "The easiest way to create a deterministic variable is to operate on or transform one or more variables in a model directly. For example, the simplest way to specify the `rate` variable above is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "with disaster_model:\n",
    "    \n",
    "    rate = switch(switchpoint >= np.arange(112), early_mean, late_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, let's say we wanted to use the mean of the `early_mean` and `late_mean` variables somehere in our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "with disaster_model:\n",
    "    \n",
    "    mean_of_means = (early_mean + late_mean)/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are called *anonymous* variables because we did not wrap it with a call to `Determinstic`, which gives it a name as its first argument. We simply specified the variable as a Python (or, Theano) expression. This is therefore the simplest way to construct a determinstic variable. The only caveat is that the values generated by anonymous determinstics at every iteration of a MCMC algorithm, for example, are not recorded to the resulting trace. So, this approach is only appropriate for intermediate values in your model that you do not wish to obtain posterior estimates for, alongside the other variables in the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Named deterministic variables\n",
    "\n",
    "To ensure that deterministic variables' values are accumulated during sampling, they should be instantiated using the **named deterministic** interface; this uses the `Deterministic` function to create the variable. Two things happen when a variable is created this way:\n",
    "\n",
    "1. The variable is given a name (passed as the first argument)\n",
    "2. The variable is appended to the model's list of random variables, which ensures that its values are tallied.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymc3 import Deterministic\n",
    "\n",
    "with disaster_model:\n",
    "    \n",
    "    rate = Deterministic('rate', switch(switchpoint >= np.arange(112), early_mean, late_mean))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'switchpoint_interval__': switchpoint_interval__,\n",
       " 'switchpoint': switchpoint,\n",
       " 'early_mean_log__': early_mean_log__,\n",
       " 'early_mean': early_mean,\n",
       " 'late_mean_log__': late_mean_log__,\n",
       " 'late_mean': late_mean,\n",
       " 'disasters': disasters,\n",
       " 'rate': rate}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "disaster_model.named_vars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factor Potentials\n",
    "\n",
    "For some applications, we want to be able to modify the joint density by incorporating terms that don't correspond to probabilities of variables conditional on parents, for example:\n",
    "\n",
    "$$p(x_0, x_2, \\ldots x_{N-1}) \\propto \\prod_{i=0}^{N-2} \\psi_i(x_i, x_{i+1})$$\n",
    "\n",
    "In other cases we may want to add probability terms to existing models. For example, suppose we want to constrain the early mean to be greater than the late mean in the disaster model, so that the joint density becomes: \n",
    "\n",
    "$$p(y,\\tau,\\lambda_1,\\lambda_2) \\propto p(y|\\tau,\\lambda_1,\\lambda_2) p(\\tau) p(\\lambda_1) p(\\lambda_2) I(|\\lambda_1-\\lambda_2| \\gt 0)$$\n",
    "\n",
    "We call such log-probability terms **factor potentials** (Jordan 2004). Bayesian\n",
    "hierarchical notation doesn't accomodate these potentials. \n",
    "\n",
    "### Creation of Potentials\n",
    "\n",
    "A potential can be created via the `Potential` function, in a way very similar to `Deterministic`'s named interface:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymc3 import Potential\n",
    "\n",
    "with disaster_model:\n",
    "    \n",
    "    rate_constraint = Potential('rate_constraint', switch((late_mean - early_mean)>0, -np.inf, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function takes just a `name` as its first argument and an expression returning the appropriate log-probability as the second argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling with MCMC\n",
    "\n",
    "PyMC's core business is using Markov chain Monte Carlo to fit virtually any probability model. This involves the assignment and coordination of a suite of **step methods**, each of which is responsible for updating one or more variables. \n",
    "\n",
    "The user's interface to PyMC's sampling algorithms is the `sample` function:\n",
    "\n",
    "```python\n",
    "sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=None, chain_idx=0, chains=None, cores=None, tune=500, progressbar=True, model=None, random_seed=None, discard_tuned_samples=True, compute_convergence_checks=True)\n",
    "```\n",
    "\n",
    "`sample` assigns particular samplers to model variables, and generates samples from them. The `draws` argument\n",
    "controls the total number of MCMC iterations. PyMC can automate most of the details of sampling, outside of the selection of the number of draws, using default settings for several parameters that control how the sampling is set up and conducted. However, users may manually intervene in the specification of the sampling by passing values to a number of keyword argumetns for `sample`.\n",
    "\n",
    "### Assigning step methods\n",
    "\n",
    "The `step` argument allows users to assign a MCMC sampling algorithm to the entire model, or to a subset of the variables in the model. For example, if we wanted to use the Metropolis-Hastings sampler to fit our model, we could pass an instance of that step method to `sample` via the `step` argument:\n",
    "\n",
    "```python\n",
    "with my_model:\n",
    "\n",
    "    trace = sample(1000, step=Metropolis())\n",
    "```\n",
    "\n",
    "or if we only wanted to assign `Metropolis` to a parameter called `β`:\n",
    "\n",
    "```python\n",
    "with my_model:\n",
    "\n",
    "    trace = sample(1000, step=Metropolis(vars=[β]))\n",
    "```\n",
    "\n",
    "When `step` is not specified by the user, PyMC3 will assign step methods to variables automatically. To do so, each step method implements a class method called `competence`. This method returns a value from 0 (incompatible) to 3 (ideal), based on the attributes of the random variable in question. `sample` assigns the step method that returns the highest competence value to each of its unallocated stochastic random variables. In general:\n",
    "\n",
    "* Binary variables will be assigned to `BinaryMetropolis` (Metropolis-Hastings for binary values)\n",
    "* Discrete variables will be assigned to `Metropolis`\n",
    "* Continuous variables will be assigned to `NUTS` (No U-turn Sampler)\n",
    "\n",
    "### Starting values\n",
    "\n",
    "The `start` argument allows for the specification of starting values for stochastic random variables in the model. MCMC algorithms begin by initializing all unknown quantities to arbitrary starting values. Though in theory the value can be any value under the support of the distribution describing the random variable, we can make sampling more difficult if an initial value is chosen in the extreme tail of the distribution, for example. If starting values are not passed by the user, default values are chosen from the mean, median or mode of the distribution.\n",
    "\n",
    "One might be tempted to initialize a MCMC simulation at the maximum *a posteriori* (MAP) estimate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Model() as disaster_model:\n",
    "\n",
    "    switchpoint = Uniform('switchpoint', lower=year.min(), upper=year.max())\n",
    "    early_mean = Exponential('early_mean', lam=0.5)\n",
    "    late_mean = Exponential('late_mean', lam=0.5)\n",
    "\n",
    "    rate = switch(switchpoint >= year, early_mean, late_mean)\n",
    "    \n",
    "    disasters = Poisson('disasters', rate, observed=disasters_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/fonnesbeck/anaconda3/envs/mcmc_tutorial/lib/python3.7/site-packages/pymc3/tuning/starting.py:61: UserWarning: find_MAP should not be used to initialize the NUTS sampler, simply call pymc3.sample() and it will automatically initialize NUTS in a better way.\n",
      "  warnings.warn('find_MAP should not be used to initialize the NUTS sampler, simply call pymc3.sample() and it will automatically initialize NUTS in a better way.')\n",
      "logp = -213.77, ||grad|| = 68.219: 100%|██████████| 9/9 [00:00<00:00, 385.53it/s]\n"
     ]
    }
   ],
   "source": [
    "from pymc3 import find_MAP\n",
    "\n",
    "with disaster_model:\n",
    "    \n",
    "    start = find_MAP()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Except for small models, starting a sampler at the posterior mode is **not recommended**. As we saw in the introduction to Hamiltonian Monte Carlo, even though the probability density is highest around the mode, the volume of the posterior distribution is very low there. Hence, it is often not in (or near) the typical set.\n",
    "\n",
    "However, for our small model things should work out okay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'switchpoint_interval__': array(0.),\n",
       " 'early_mean_log__': array(0.91451801),\n",
       " 'late_mean_log__': array(-0.1043578),\n",
       " 'switchpoint': array(1906.),\n",
       " 'early_mean': array(2.49557212),\n",
       " 'late_mean': array(0.9009029)}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (2 chains in 2 jobs)\n",
      "CompoundStep\n",
      ">Metropolis: [late_mean]\n",
      ">Metropolis: [early_mean]\n",
      ">Metropolis: [switchpoint]\n",
      "Sampling 2 chains: 100%|██████████| 2000/2000 [00:00<00:00, 2515.45draws/s]\n",
      "The estimated number of effective samples is smaller than 200 for some parameters.\n"
     ]
    }
   ],
   "source": [
    "from pymc3 import sample, Metropolis\n",
    "\n",
    "with disaster_model:\n",
    "    trace = sample(step=Metropolis(), cores=2, start=start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing samples\n",
    "\n",
    "Notice in the above call to `sample` that output is assigned to a variable we have called `trace`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MultiTrace: 2 chains, 500 iterations, 6 variables>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `MultiTrace` object is a data structure that stores the samples from an MCMC run in a tabular structure. By default, `sample` will create a new `MultiTrace` object that stores its samples in memory, as a NumPy `ndarray`. We can override the default behavior by specifying the `trace` argument. There are three options:\n",
    "\n",
    "1. Selecting an alternative database backend to keeping samples in an `ndarray`. Passing either `\"text\"` or `\"sqlite\"`, for example, will save samples to text files or a SQLite database, respectively. An instance of a backend can also be passed.\n",
    "2. Passing a list of variables will only record samples for the subset of variables specified in the list. These will be stored in memory.\n",
    "3. An existing `MultiTrace` object. This will add samples to an existing backend.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Only 100 samples in chain.\n",
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (2 chains in 2 jobs)\n",
      "NUTS: [late_mean, early_mean, switchpoint]\n",
      "Sampling 2 chains: 100%|██████████| 200/200 [00:00<00:00, 1402.46draws/s]\n",
      "The chain contains only diverging samples. The model is probably misspecified.\n",
      "The acceptance probability does not match the target. It is 0.0, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "The chain contains only diverging samples. The model is probably misspecified.\n",
      "The acceptance probability does not match the target. It is 0.0, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "The gelman-rubin statistic is larger than 1.4 for some parameters. The sampler did not converge.\n"
     ]
    }
   ],
   "source": [
    "with disaster_model:\n",
    "    db_trace = sample(100, tune=0, cores=2, trace='sqlite')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cleaning up!\n",
    "!rm mcmc.sqlite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I recommend converting MCMC sample output to an ArviZ `InferenceData` object. Output data are stored in a robust and flexible xarray `Dataset` and allows for easy export to NetCDF for serialization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Inference data with groups:\n",
       "\t> posterior\n",
       "\t> sample_stats\n",
       "\t> observed_data"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from arviz import from_pymc3\n",
    "\n",
    "model_output = from_pymc3(trace)\n",
    "model_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will explore the output more in the next section, but the `InferenceData` object stores the posterior samples, the data that was used to fit the model, as well as a number of statistics related to the sampling procedure, which are useful for convergence diagnostic purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "xarray.core.dataset.Dataset"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(model_output.posterior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'trace.netcdf'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_output.to_netcdf('trace.netcdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serialized `InferenceData` objects can easily be re-imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from arviz import from_netcdf\n",
    "\n",
    "imported_model_output = from_netcdf('trace.netcdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert imported_model_output.posterior==model_output.posterior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Clean up\n",
    "!rm trace.netcdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parallel sampling\n",
    "\n",
    "Nearly all modern desktop computers have multiple CPU cores, and running multiple MCMC chains is an **embarrasingly parallel** computing task. It is therefore relatively simple to run chains in parallel in PyMC3. This is done by setting the `cores` argument in `sample` to some value between 2 and the number of cores on your machine (you can specify more chains than cores, but you will not gain efficiency by doing so). The default value of `cores` is `None`, which will select the number of CPUs on your machine, to a maximum of 4. \n",
    "\n",
    "> Keep in mind that some chains might themselves be multithreaded via openmp or BLAS. In those cases it might be faster to set this to 1.\n",
    "\n",
    "By default, PyMC3 will run a sample a minimum of 2 and a maximum of `cores` chains. However, the number of chains sampled can be set independently of the number of cores by specifying the `chains` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Only 100 samples in chain.\n",
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 2 jobs)\n",
      "NUTS: [late_mean, early_mean, switchpoint]\n",
      "Sampling 4 chains: 100%|██████████| 800/800 [01:02<00:00,  6.31draws/s]\n",
      "The acceptance probability does not match the target. It is 0.5617654510017702, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The acceptance probability does not match the target. It is 0.6764064698044092, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The acceptance probability does not match the target. It is 0.593575606842076, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The gelman-rubin statistic is larger than 1.4 for some parameters. The sampler did not converge.\n",
      "The number of effective samples is smaller than 10% for some parameters.\n"
     ]
    }
   ],
   "source": [
    "with disaster_model:\n",
    "    ptrace = sample(100, tune=100, chains=4, cores=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running $n$ iterations with $c$ chains will result in $n \\times c$ samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400,)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ptrace['early_mean'].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to specify different arguments for each chain, a list of argument values can be passed to `sample` as appropriate. For example, if we want to initialize random variables to particular (*e.g.* dispersed) values, we can pass a list of dictionaries to `start`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Only 10 samples in chain.\n",
      "Multiprocess sampling (2 chains in 2 jobs)\n",
      "NUTS: [late_mean, early_mean, switchpoint]\n",
      "Sampling 2 chains: 100%|██████████| 220/220 [00:06<00:00, 10.55draws/s]\n",
      "/home/fonnesbeck/anaconda3/envs/mcmc_tutorial/lib/python3.7/site-packages/pymc3/sampling.py:464: UserWarning: The number of samples is too small to check convergence reliably.\n",
      "  warnings.warn(\"The number of samples is too small to check convergence reliably.\")\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n"
     ]
    }
   ],
   "source": [
    "with disaster_model:\n",
    "    ptrace = sample(10, tune=100, cores=2, discard_tuned_samples=False, init=None,\n",
    "                    start=[{'early_mean':0.1}, {'early_mean':10}]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1.28809568, 1.28809568, 2.1176523 , 2.34611383, 2.57994185]),\n",
       " array([10.        , 10.        ,  4.9648614 ,  2.59483307,  2.9442155 ])]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[chain[:5] for chain in ptrace.get_values('early_mean', combine=False)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating several chains is generally recommended because it aids in model checking, allowing statistics such as the potential scale reduction factor ($\\hat{R}$) and effective sample size to be calculated, as we will see in the model checking section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step methods\n",
    "\n",
    "Step method classes handle individual stochastic variables, or sometimes groups of them. They are responsible for making the variables they handle take **single MCMC steps** conditional on the rest of the model. Each PyMC step method (usually subclasses of `ArrayStep`) implements a method called `astep()`, which is called iteratively by `sample`. \n",
    "\n",
    "All step methods share an optional argument `vars` that allows a particular subset of variables to be handled by the step method instance. Particular step methods will have additional arguments for setting parameters and preferences specific to that sampling algorithm.\n",
    "\n",
    "> NB: when a PyMC function or method has an argument called `vars` it is expecting a list of variables (*i.e.* the variables themselves), whereas arguments called `varnames` expect a list of variables names (*i.e.* strings)\n",
    "\n",
    "### HamiltonianMC\n",
    "\n",
    "The Hamiltonian Monte Carlo algorithm is implemented in the `HamiltonianMC` class. Being a gradient-based sampler, it is only suitable for **continuous random variables**. Several optional arguments can be provided by the user. The algorithm is **non-adaptive**, so the parameter values passed at instantiation are fixed at those values throughout sampling.\n",
    "\n",
    "`HamiltonianMC` requires a scaling matrix parameter `scaling`, which is analogous to the variance parameter for the jump proposal distribution in Metropolis-Hastings, although it is used somewhat differently here. The matrix gives an approximate shape of the posterior distribution, so that `HamiltonianMC` does not make jumps that are too large in some directions and too small in other directions. It is important to set this scaling parameter to a reasonable value to facilitate efficient sampling. This is especially true for models that have many unobserved stochastic random variables or models with highly non-normal posterior distributions. \n",
    "\n",
    "Fortunately, `HamiltonianMC` can often make good guesses for the scaling parameters. If you pass a point in parameter space (as a dictionary of variable names to parameter values, the same format as returned by `find_MAP`), it will look at the **local curvature** of the log posterior-density (the diagonal of the Hessian matrix) at that point to guess values for a good scaling vector, which can result in a good scaling value. Also, the MAP estimate is often a good point to use to initiate sampling. \n",
    "\n",
    "- `scaling` \n",
    ": Scaling for momentum distribution. If a 1-dimensional array is passed, it is interpreted as a matrix diagonal.\n",
    "            \n",
    "- `step_scale` \n",
    ": Size of steps to take, automatically scaled down by $1/n^{0.25}$. Defaults to .25.\n",
    "            \n",
    "- `path_length` \n",
    ": total length to travel during leapfrog. Defaults to 2.\n",
    "            \n",
    "- `is_cov` \n",
    ": Flag for treating scaling as a covariance matrix/vector, if True. Treated as precision otherwise.\n",
    "            \n",
    "- `step_rand` \n",
    ": A function which takes the step size and returns an new one used to randomize the step size at each iteration.\n",
    "\n",
    "\n",
    "### NUTS\n",
    "\n",
    "A disadgantage of the HMC sampler is that there are key hyperparameters that require tuning for sampling to proceed efficiently. Hoffman and Gelman (2014) developed an auto-tuning variant of HMC that takes care of selecting path lengths and step sizes.\n",
    "\n",
    "`NUTS` is the No U-turn Sampler of Hoffman and Gelman (2014), an adaptive version of Hamiltonian MC that **automatically tunes** the step size and number on the fly. NUTS uses a recursive algorithm to build a set of likely candidate points that spans a wide swath of the target distribution. True to its name, it stops automatically when it starts to double back and retrace its steps.\n",
    "\n",
    "The algorithm employs **binary doubling**, which takes leapfrog steps alternating in direction with respect to the initial gradient. That is, one step is taken in the forward direction, two in the reverse direction, then four, eight, etc. The result is a balanced, binary tree with nodes comprised of Hamiltonian states. \n",
    "\n",
    "![](images/binary_doubling.png)\n",
    "\n",
    "Doubling process builds a balanced binary tree whose leaf nodes correspond to\n",
    "position-momentum states. Doubling is halted when the subtrajectory from the\n",
    "leftmost to the rightmost nodes of any balanced subtree of the overall binary tree starts to double back on itself\n",
    "\n",
    "![](images/uturn.png)\n",
    "\n",
    "To ensure detailed balance, a slice variable is sampled from:\n",
    "\n",
    "$$ u \\sim \\text{Uniform}(0, \\exp[L(\\theta) - 0.5 r \\cdot r])$$\n",
    "\n",
    "where $r$ is the initial momentum vector. The next sample is then chosen uniformly from the points in the remaining balanced tree.\n",
    "\n",
    "In addition to the arguments to `HamiltonianMC`, `NUTS` takes additional parameters to controls the tuning. The most important of these is the target acceptance rate for the Metropolis acceptance phase of the algorithm, `taget_accept`. \n",
    "Sometimes if the NUTS struggles to sample efficiently, changing this parameter above the default target rate of 0.8 will improve sampling (the original recommendation by Hoffman & Gelman was 0.6). Increasing the rate very high will also make the sampler more conservative, however, taking many small steps at every iteration. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Only 100 samples in chain.\n",
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (2 chains in 2 jobs)\n",
      "NUTS: [late_mean, early_mean, switchpoint]\n",
      "Sampling 2 chains: 100%|██████████| 600/600 [00:36<00:00, 16.63draws/s]\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The chain reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n",
      "The gelman-rubin statistic is larger than 1.4 for some parameters. The sampler did not converge.\n",
      "The number of effective samples is smaller than 10% for some parameters.\n"
     ]
    }
   ],
   "source": [
    "with disaster_model:\n",
    "    trace_99 = sample(100, tune=200, cores=2, target_accept=0.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is rarely a reason to use `HamiltonianMC` rather than `NUTS`. It is the default sampler for continuous variables in PyMC3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metropolis\n",
    "\n",
    "``Metropolis`` implements a Metropolis-Hastings step, as described the theory section, and is designed to handle float- and integer-valued variables.\n",
    "\n",
    "A `Metropolis` step method can be instantiated with any of several optional arguments:\n",
    "\n",
    "\n",
    "- `S`\n",
    ":   This sets the proposal standard deviation or covariance matrix.\n",
    "\n",
    "- `proposal_dist`\n",
    ":   A function that generates zero-mean random deviates used as proposals. Defaults to the normal distribution.\n",
    "\n",
    "- `scaling`\n",
    ":   An initial scale factor for the proposal\n",
    "\n",
    "- `tune_interval`\n",
    ":   The number of intervals between tuning updates to `scaling` factor.\n",
    "\n",
    "When the step method is instantiated, the `proposal_dist` is parameterized with the value passed for `S`. While sampling, the value of `scaling` is used to scale the value proposed by `proposal_dist`, and this value is tuned throughout the MCMC run. During tuning, the acceptance ratio of the step method is examined, and this scaling factor\n",
    "is updated accordingly. Tuning only occurs when the acceptance rate is **lower than 20%** or **higher than 50%**; rates between 20-50% are considered optimal for Metropolis-Hastings sampling. The default tuning interval (`tune_interval`) is 100 iterations.\n",
    "\n",
    "Although tuning will continue throughout the sampling loop, it is important to verify that the\n",
    "**diminishing tuning** condition of [Roberts and Rosenthal (2007)](http://projecteuclid.org/DPubS?service=UI&version=1.0&verb=Display&handle=euclid.jap/1183667414) is satisfied: the\n",
    "amount of tuning should decrease to zero, or tuning should become very infrequent.\n",
    "\n",
    "`Metropolis` handles discrete variable types automatically by rounding the proposed values and casting them to integers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### BinaryMetropolis\n",
    "\n",
    "While binary (boolean) variables can be handled by the `Metropolis` step method, sampling will be very inefficient. The `BinaryMetropolis` class is optimized to handle binary variables, by one of only two possible values. The only tuneable parameter is the `scaling` argument, which is used to vary the Bernoulli probability:\n",
    "\n",
    "    p_jump = 1. - .5 ** self.scaling\n",
    "\n",
    "This value is compared to pseudo-random numbers generated by the step method, to determine whether a 0 or 1 is proposed.\n",
    "\n",
    "`BinaryMetropolis` will be automatically selected for random variables that are distributed as Bernoulli, or categorical with only 2 categories."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slice\n",
    "\n",
    "Though the Metropolis-Hastings algorithm is easy to implement for a variety of models, its efficiency is poor. We have seen that it is possible to tune Metropolis samplers, but it would be nice to have a \"black-box\" method that works for arbitrary continuous distributions, which we may know little about a priori.\n",
    "\n",
    "The **slice sampler** (Neal 2003) improves upon the Metropolis sampler by being both efficient and easy to program generally. The idea is to first sample from the conditional distribution for $y$ (i.e., $Pr(x)$) given some current value of $x$, which is uniform over the $(0,f(x))$, and conditional on this value for $y$, then sample $x$, which is uniform on $S = {x : y < f (x)}$.\n",
    "\n",
    "The steps required to perform a single iteration of the slice sampler to update the current value of $x_i$ is as follows:\n",
    "\n",
    "1. Sample $y$ uniformly on (0,f(xi)).\n",
    "2. Use this value $y$ to define a horizontal *slice* $S = {x : y < f (x)}$.\n",
    "3. Establish an interval, I=(xa,xb), around xi that contains most of the slice.\n",
    "4. Sample $x_{i+1}$ from the region of the slice overlaping I.\n",
    "\n",
    "Hence, slice sampling employs an **auxilliary variable** ($y$) that is not retained at the end of the iteration. Note that in practice one may operate on the log scale such that $g(x) = \\log(f (x))$ to avoid floating-point underflow. In this case, the auxiliary variable becomes $z = log(y) = g(x_i) − e$, where $e \\sim \\text{Exp}(1)$, resulting in the slice $S = \\{x : z < g(x)\\}$.\n",
    "\n",
    "There are many ways of establishing and sampling from the interval $I$, with the only restriction being that the resulting Markov chain leaves $f(x)$ **invariant**. The objective is to include as much of the slice as possible, so that the potential step size can be large, but not (much) larger than the slice, so that the sampling of invalid points is minimized. Ideally, we would like it to be the slice itself, but it may not always be feasible to determine (and certainly not automatically).\n",
    "\n",
    "In PyMC3, the `Slice` class implements the **univariate** slice sampler. It is suitable for univariate, continuous variables. There is a single user-defined parameter `w`, which sets the width of the initial slice. If not specified, it defaults to a width of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (2 chains in 2 jobs)\n",
      "CompoundStep\n",
      ">Slice: [late_mean]\n",
      ">Slice: [early_mean]\n",
      ">Slice: [switchpoint]\n",
      "Sampling 2 chains: 100%|██████████| 5000/5000 [00:09<00:00, 539.86draws/s]\n"
     ]
    }
   ],
   "source": [
    "from pymc3 import Slice\n",
    "\n",
    "with disaster_model:\n",
    "    \n",
    "    slice_trace = sample(2000, cores=2, step=Slice())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from arviz import plot_trace\n",
    "\n",
    "plot_trace(slice_trace, var_names=['early_mean','late_mean']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## To Learn More\n",
    "\n",
    "- Hoffman MD, Gelman A. 2014. The No-U-turn sampler: adaptively setting path lengths in Hamiltonian Monte Carlo. The Journal of Machine Learning Research. 15(1):1593-1623.\n",
    "- M.I. Jordan. 2004. Graphical models. Statist. Sci., 19(1):140–155.\n",
    "- Neal, R. M. 2003. Slice sampling. The Annals of Statistics, 31(3), 705–767. doi:10.1111/1467-9868.00198"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
